#include "Include.h"
#include "Jeu.h"
#include "AffichageNcurses.h"
#include <ncurses.h>

#define LARGEUR 30
#define HAUTEUR 10


char *choixMenu[] =
{
    "1 Joueur",
        "J1 vs J2",
        "J1 vs IA",
        "Bataille",
        "Exit",
};

int startx = 0;
int starty = 0;

int n_choix = sizeof(choixMenu) / sizeof(char *);


int affichageNcurses()
{
        s_Jeu Jeu;
        s_Bomberman Bomberman;
        jeuInit(&Jeu);
        bombermanInit(&Bomberman);
        initNcurses();
        affEcranTitre();
        afficheMenu();
        mode1Joueur(&Jeu);
        endwin();
        return 0;
}

void afficheMenu()
{
    WINDOW *fenetreMenu;

    int surligne = 1;
        int choix = 0;
        int c;

        startx = (80 - LARGEUR) / 2;
        starty = (24 - HAUTEUR) / 2;

        fenetreMenu = newwin(HAUTEUR, LARGEUR, starty, startx);
        keypad(fenetreMenu, TRUE);
        mvprintw(0, 0, "Utilisez les fleches et 'entree' pour selectionner et valider votre choix");
        refresh();
        initMenu(fenetreMenu, surligne);
        while(1)
        {       c = wgetch(fenetreMenu);
                switch(c)
                {       case KEY_UP:
                                if(surligne == 1)
                                        surligne = n_choix;
                                else
                                        --surligne;
                                break;
                        case KEY_DOWN:
                                if(surligne == n_choix)
                                        surligne = 1;
                                else
                                        ++surligne;
                                break;
                        case 10:
                                choix = surligne;
                                break;
                        default:
                                refresh();
                                break;
                }
                initMenu(fenetreMenu, surligne);
                if(choix != 0)
                        break;
        }
        mvprintw(23, 0, "You chose choix %d with choix string %s\n", choix, choixMenu[choix - 1]);
        clrtoeol();
        refresh();
}

void initNcurses()
{
    initscr();
        keypad(stdscr, TRUE);
        raw ();
        noecho();
        /** Fonction d'initialisations, permettant de
        * commencer le mode NCURSES
        * d'autoriser la lecture des touches de fonctions (F1, F2 ...), des fleches etc ...
        * de desactiver le line buffering
        * d'éviter l'affichage de caractères spéciaux bizarres à l'écran pendant une saisie (ex : [[^ ) */
    cbreak();
    clear();
    endwin();

}

void mode1Joueur(s_Jeu *pJeu)
{
    int ch, c;
    int ecranLarg, ecranHaut;

    ecranLarg = (COLS - (pJeu->terrain.largeur))/2;
    ecranHaut = (LINES - (pJeu->terrain.hauteur))/2;
    /** pour que la fenêtre soit centrée */

    clear();
    /** Efface l'ecran */

    attron(A_BOLD | A_REVERSE);
        mvprintw(23,1,"CTRL+C pour quitter\n");
    attroff(A_BOLD | A_REVERSE);

    refresh();
    /** On affiche en bas de la fenetre le message puis on rafraichit la fenetre */

    ecran = nouvelleFenetre(pJeu->terrain.hauteur+1, pJeu->terrain.largeur+1, ecranHaut, ecranLarg);
    /** On crée une fenetre de la même dimension que le terrain.
     * (+1 pour compter les murs)
     * et on affiche la fenetre aux coordonnees ecranHaut/Larg pour qu'elle soit centrée */

    //wborder(ecran,'|','|','-','-','/','\\','\\','/');

    stats = nouvelleFenetre(3,pJeu->terrain.largeur+1, 2,ecranLarg);
    /** */
    mvwprintw(stats, 1,1,  "Bombes : %d",pJeu->bomberman.bombe.nbBombes);
    wrefresh(stats);


    keypad(ecran, TRUE);
    /** Pour la saisie au clavier */

    pJeu->bomberman.x=1;
    pJeu->bomberman.y=1;

    initTerrain(&(pJeu->terrain));
    bombermanInit(&pJeu->bomberman);
    pJeu->terrain.tabTerrain[bombermanGetY(&pJeu->bomberman)][bombermanGetX(&pJeu->bomberman)]=BOMBERMAN;
    afficheTerrain(ecran,*pJeu);
    wrefresh(ecran);

    while((ch=getch())!=EOF)
    {

            switch(ch)
            {

                case KEY_LEFT :
                    jeuActionClavier(pJeu,KEY_LEFT,ecran);
                    afficheTerrain(ecran,*pJeu);
                    wrefresh(ecran);
                    break;
                case KEY_RIGHT :
                    jeuActionClavier(pJeu,KEY_RIGHT,ecran);
                    afficheTerrain(ecran,*pJeu);
                    wrefresh(ecran);
                    break;
                case KEY_UP :
                    jeuActionClavier(pJeu,KEY_UP,ecran);
                    afficheTerrain(ecran,*pJeu);
                    wrefresh(ecran);
                    break;
                case KEY_DOWN :
                    jeuActionClavier(pJeu,KEY_DOWN, ecran);
                    afficheTerrain(ecran,*pJeu);
                    wrefresh(ecran);
                    break;
                case 'b' :
                    jeuActionClavier(pJeu,'b',ecran);
                    mvwprintw(stats,1,1,"Bombes : %d",pJeu->bomberman.bombe.nbBombes);
                    wrefresh(stats);
                    //delaiExploseBombe(pJeu);
                    wrefresh(ecran);
                    break;
            }
    }

    detruitFenetre(ecran);
    detruitFenetre(stats);
    libTerrain(&(pJeu->terrain));
    endwin();
}

void afficheTerrain(WINDOW* ecran, s_Jeu pJeu)
{
    int i,j;
    for(i=1;i<getDimX(&pJeu.terrain);++i)
    {
        for(j=1;j<getDimY(&pJeu.terrain);++j)
        {
            mvwprintw(ecran, j,i,  "%c", terGetXY(&pJeu.terrain,i,j));
            /** On parcours toutes les cases du Terrain, et on les affiche une à une à l'"ecran" */
        }
    }
}

void affEcranTitre()
{
    char *ecranTitre;
    ecranTitre = "==== Bomberman ====";

    start_color();
    /** permet d'utiliser des couleurs dans le terminal */
    init_pair(1, COLOR_CYAN,COLOR_CYAN);

    //attron (A_STANDOUT | A_BOLD); /** Affichage du texte en gras et surligné */
    //attroff(A_STANDOUT | A_BOLD); /** Désactive l'affichage en gras */

    mvprintw((LINES/2),(COLS-strlen(ecranTitre))/2, "%s", ecranTitre);
    /** Pour un affichage centré*/
    mvchgat((LINES/2),((COLS-strlen(ecranTitre)-2)/2),-1,A_BLINK,0,NULL);
    /** Le texte clignote */
    refresh();
    /** affiche les changements à l'ecran */
    getch();
    /** attends une entree au clavier de l'utilisateur */

}

void initMenu(WINDOW *fenetreMenu, int surligne)
{
    int x, y, i;

    x = 2;
    y = 2;

    box(fenetreMenu, 0, 0);
    /** 0, 0 caractères par défaut
     * pour les lignes horizontales et verticales */
    for(i = 0; i < n_choix; ++i)
    {
        if(surligne == i + 1) /* Surligne le choix en cours */
        {
            wattron(fenetreMenu, A_REVERSE);
            /** WindowATTRibutON : active les attributs en parametre dans la fenetre donné */
            mvwprintw(fenetreMenu, y, x, "%s", choixMenu[i]);
            /** affiche les choix possibles dans la fenetre */
            wattroff(fenetreMenu, A_REVERSE);
            /** WindowATTRibutOFF : met fin aux attributs activés par attron */
        }
        else
            mvwprintw(fenetreMenu, y, x, "%s", choixMenu[i]);
        ++y;
        /** 1 choix par ligne */
    }
    wrefresh(fenetreMenu);
}

WINDOW *nouvelleFenetre(int hauteur, int largeur, int fenetreHaut, int fenetreLarg)
{
    WINDOW *fenetre;

    fenetre = newwin(hauteur, largeur, fenetreHaut, fenetreLarg);
    box(fenetre, 0 , 0);
    /** 0, 0 caractères par défaut
     * pour les lignes horizontales et verticales */


    wrefresh(fenetre);
    /** affiche la fenêtre  */

    return fenetre;
}

void detruitFenetre(WINDOW *fenetre)
{
        wborder(fenetre, ' ', ' ', ' ',' ',' ',' ',' ',' ');
        /** Les parametres sont :
         * 1. win: La fenetre sur laquelle on opère
         * 2. ls: caractère que l'on applique au coté gauche
         * 3. rs: caractère que l'on applique au coté droit
         * 4. ts: caractère que l'on applique au haut de la fenêtre
         * 5. bs: caractère que l'on applique au bas de la fenêtre
         * 6. tl: caractère que l'on applique au coin supérieur gauche
         * 7. tr: caractère que l'on applique au coin supérieur droit
         * 8. bl: caractère que l'on applique au coin inférieur gauche
         * 9. br: caractère que l'on applique au coin inférieur droit
         */
        wrefresh(fenetre);
        /** Met à jour la fenetre à l'ecran */
        delwin(fenetre);
        /** On detruit la fenetre */
}

